{ "cells": [ { "cell_type": "code", "execution_count": 8, "id": "67d644ad-6b26-4f07-b347-cf4cf43eee76", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Simulated data exported as 'simulated_experiment_data.csv' and return paths as 'return_paths.csv'\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:202: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'forecast_round_{round_num}'] = forecast_adj.round(2)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:203: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'allocation_round_{round_num}'] = allocation.round(0)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:204: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'optimal_allocation_round_{round_num}'] = optimal_allocation.round(6)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:149: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'chosen_path_round_{round_num}'] = chosen\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:201: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'best_forecast_round_{round_num}'] = best_forecast.round(6)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:202: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'forecast_round_{round_num}'] = forecast_adj.round(2)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:203: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'allocation_round_{round_num}'] = allocation.round(0)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:204: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'optimal_allocation_round_{round_num}'] = optimal_allocation.round(6)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:149: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'chosen_path_round_{round_num}'] = chosen\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:201: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'best_forecast_round_{round_num}'] = best_forecast.round(6)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:202: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'forecast_round_{round_num}'] = forecast_adj.round(2)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:203: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'allocation_round_{round_num}'] = allocation.round(0)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:204: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'optimal_allocation_round_{round_num}'] = optimal_allocation.round(6)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:149: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'chosen_path_round_{round_num}'] = chosen\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:201: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'best_forecast_round_{round_num}'] = best_forecast.round(6)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:202: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'forecast_round_{round_num}'] = forecast_adj.round(2)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:203: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'allocation_round_{round_num}'] = allocation.round(0)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:204: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'optimal_allocation_round_{round_num}'] = optimal_allocation.round(6)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:149: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'chosen_path_round_{round_num}'] = chosen\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:201: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'best_forecast_round_{round_num}'] = best_forecast.round(6)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:202: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'forecast_round_{round_num}'] = forecast_adj.round(2)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:203: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'allocation_round_{round_num}'] = allocation.round(0)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:204: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'optimal_allocation_round_{round_num}'] = optimal_allocation.round(6)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:149: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'chosen_path_round_{round_num}'] = chosen\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:201: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'best_forecast_round_{round_num}'] = best_forecast.round(6)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:202: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'forecast_round_{round_num}'] = forecast_adj.round(2)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:203: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'allocation_round_{round_num}'] = allocation.round(0)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:204: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'optimal_allocation_round_{round_num}'] = optimal_allocation.round(6)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:149: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'chosen_path_round_{round_num}'] = chosen\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:201: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'best_forecast_round_{round_num}'] = best_forecast.round(6)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:202: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'forecast_round_{round_num}'] = forecast_adj.round(2)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:203: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'allocation_round_{round_num}'] = allocation.round(0)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:204: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'optimal_allocation_round_{round_num}'] = optimal_allocation.round(6)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:149: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'chosen_path_round_{round_num}'] = chosen\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:201: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'best_forecast_round_{round_num}'] = best_forecast.round(6)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:202: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'forecast_round_{round_num}'] = forecast_adj.round(2)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:203: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'allocation_round_{round_num}'] = allocation.round(0)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:204: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'optimal_allocation_round_{round_num}'] = optimal_allocation.round(6)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:149: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'chosen_path_round_{round_num}'] = chosen\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:201: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'best_forecast_round_{round_num}'] = best_forecast.round(6)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:202: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'forecast_round_{round_num}'] = forecast_adj.round(2)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:203: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'allocation_round_{round_num}'] = allocation.round(0)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:204: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'optimal_allocation_round_{round_num}'] = optimal_allocation.round(6)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:149: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'chosen_path_round_{round_num}'] = chosen\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:201: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'best_forecast_round_{round_num}'] = best_forecast.round(6)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:202: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'forecast_round_{round_num}'] = forecast_adj.round(2)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:203: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'allocation_round_{round_num}'] = allocation.round(0)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:204: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'optimal_allocation_round_{round_num}'] = optimal_allocation.round(6)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:149: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'chosen_path_round_{round_num}'] = chosen\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:201: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'best_forecast_round_{round_num}'] = best_forecast.round(6)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:202: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'forecast_round_{round_num}'] = forecast_adj.round(2)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:203: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'allocation_round_{round_num}'] = allocation.round(0)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_51056/4212419727.py:204: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " data[f'optimal_allocation_round_{round_num}'] = optimal_allocation.round(6)\n" ] } ], "source": [ "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt # ← add this at the top\n", "import os\n", "\n", "os.chdir('/Users/francaglenzer/Local documents/robo-advice/simulation')\n", "# Parameters\n", "n_participants = 200\n", "np.random.seed(42)\n", "\n", "# Experiment parameters\n", "mu = 0.06\n", "sigma = 0.20\n", "\n", "gender = np.random.choice(['male', 'female'], size=n_participants, p=[0.6, 0.4])\n", "age_raw = np.random.lognormal(mean=2.8, sigma=0.3, size=n_participants)\n", "age = np.clip(np.round(age_raw + 15), 18, 65).astype(int)\n", "\n", "# Education dependent on age\n", "education = []\n", "for a in age:\n", " if a < 22:\n", " edu = np.random.choice(['high_school', 'bachelor'], p=[0.8, 0.2])\n", " elif a < 24:\n", " edu = np.random.choice(['high_school', 'bachelor', 'master'], p=[0.3, 0.6, 0.1])\n", " else:\n", " edu = np.random.choice(['high_school', 'bachelor', 'master'], p=[0.1, 0.5, 0.4])\n", " education.append(edu)\n", "education = np.array(education)\n", "\n", "# Occupation dependent on age\n", "occupation = []\n", "for a in age:\n", " if a < 22:\n", " occ = np.random.choice(['student', 'employed'], p=[0.9, 0.1])\n", " elif a < 24:\n", " occ = np.random.choice(['student', 'employed'], p=[0.6, 0.4])\n", " else:\n", " occ = np.random.choice(['student', 'employed'], p=[0.2, 0.8])\n", " occupation.append(occ)\n", "occupation = np.array(occupation)\n", "\n", "# Income positively correlated with age and education\n", "income = []\n", "for a, edu in zip(age, education):\n", " if edu == 'high_school':\n", " inc = np.random.choice(['low', 'medium'], p=[0.8, 0.2])\n", " elif edu == 'bachelor':\n", " inc = np.random.choice(['low', 'medium', 'high'], p=[0.4, 0.5, 0.1])\n", " else: # graduate level\n", " inc = np.random.choice(['medium', 'high'], p=[0.4, 0.6])\n", "\n", " if a > 35:\n", " if inc == 'low':\n", " inc = np.random.choice(['low', 'medium'], p=[0.3, 0.7])\n", " elif inc == 'medium':\n", " inc = np.random.choice(['medium', 'high'], p=[0.4, 0.6])\n", "\n", " income.append(inc)\n", "income = np.array(income)\n", "\n", "# Stock investing experience dependent on gender, income, education\n", "stock_exp = []\n", "for g, inc, edu in zip(gender, income, education):\n", " prob = 0.2\n", " if g == 'male':\n", " prob += 0.1\n", " if inc == 'high':\n", " prob += 0.2\n", " elif inc == 'medium':\n", " prob += 0.1\n", " if edu in ['master', 'phd']:\n", " prob += 0.15\n", " elif edu == 'bachelor':\n", " prob += 0.1\n", "\n", " exp = np.random.choice(['yes', 'no'], p=[prob, 1 - prob])\n", " stock_exp.append(exp)\n", "stock_exp = np.array(stock_exp)\n", "\n", "\n", "# Risk aversion baseline (lottery allocation)\n", "lottery_allocation = (\n", " 20 + 30 * (gender == 'male')\n", " + 15 * (age < 30)\n", " + 25 * (stock_exp == 'yes')\n", " - 20 * (income == 'low')\n", " + 30 * (income == 'high')\n", " + np.random.normal(0.0, 20, n_participants)\n", ").clip(1, 100)\n", "\n", "# Calculate risk aversion parameter\n", "RA = mu / (lottery_allocation / 100 * sigma**2)\n", "\n", "# Robo conditions\n", "robo_condition = np.random.choice([1, 2, 3, 4], size=n_participants) # 2: forecast 3: allo 4: allo+forecast\n", "\n", "# Generate return paths dataframe\n", "paths = pd.DataFrame({\n", " 'path_id': np.arange(1, 31),\n", " 'best_forecast': np.random.normal(0.0607, 0.20, 30),\n", " 'last_period_return': np.random.normal(0.0607, 0.20, 30)\n", "})\n", "\n", "# DataFrame initialization\n", "data = pd.DataFrame({\n", " 'gender': gender,\n", " 'age': age,\n", " 'education': education,\n", " 'occupation': occupation,\n", " 'income': income,\n", " 'stock_exp': stock_exp,\n", " 'lottery_allocation': lottery_allocation.round(),\n", " 'RA_parameter': RA,\n", " 'robo_condition': robo_condition\n", "})\n", "\n", "# before the loop: build one random permutation of paths for each participant\n", "path_ids = paths['path_id'].values\n", "n_rounds = len(path_ids)\n", "if n_rounds != 30:\n", " raise ValueError(\"Number of rounds must equal number of unique paths\")\n", "\n", "# assignments[i] is a length‑30 array of the path‐IDs in random order for participant i\n", "assignments = np.stack([\n", " np.random.permutation(path_ids)\n", " for _ in range(n_participants)\n", "])\n", "\n", "\n", "\n", "# 1) Draw each subject’s pessimism bias (under‐forecasting in decimals)\n", "pessimism_bias = np.random.normal(loc=0.02, scale=0.01, size=n_participants)\n", "\n", "# 2) How much the robo “repairs” that bias\n", "attenuation = 0.8\n", "\n", "# 3) Allocation boosts (%‐points)\n", "delta_robo = 15 # with robo present\n", "delta_post = 5 # after robo (post‐treatment)\n", "\n", "# 4) Which treatments involve robo‐forecast vs robo‐allocation\n", "mask_forecast_treat = np.isin(robo_condition, [3, 4])\n", "mask_alloc_treat = np.isin(robo_condition, [2, 4])\n", "\n", "for round_num in range(1, n_rounds + 1):\n", " # — pick path & record —\n", " chosen = assignments[:, round_num-1]\n", " data[f'chosen_path_round_{round_num}'] = chosen\n", "\n", " info = paths.set_index('path_id').loc[chosen]\n", " best_forecast = info['best_forecast'].values\n", " last_return = info['last_period_return'].values\n", "\n", " # — subjective forecast (10% use last‐period return) —\n", " use_last = np.random.rand(n_participants) < 0.1\n", " forecast = np.where(use_last, last_return, best_forecast)\n", "\n", " # — apply pessimism bias —\n", " forecast_biased = forecast - pessimism_bias\n", "\n", " # — identify robo vs post‐robo vs baseline rounds —\n", " in_window = (6 <= round_num <= 25) # scalar\n", " has_robo = in_window & (robo_condition != 1) \n", " after_robo = (round_num > 25) & robo_condition!=1\n", "\n", " # — attenuate bias in robo rounds —\n", " forecast_adj = forecast_biased.copy()\n", " forecast_adj[has_robo] += attenuation * pessimism_bias[has_robo]\n", "\n", " # — blind robo forecast override —\n", " follow_robo = (np.random.rand(n_participants) < 0.3)\n", " # only forecast‐treat participants who follow robo see the true best_forecast\n", " forecast_adj = np.where(\n", " has_robo & mask_forecast_treat & follow_robo,\n", " best_forecast,\n", " forecast_adj\n", " )\n", "\n", " # Optimal allocation:\n", " optimal_allocation_frac = best_forecast / (RA * sigma**2)\n", " optimal_allocation = (optimal_allocation_frac*100).clip(0,100)\n", " # — compute the “optimal” fraction → percentage & clip —\n", " alloc_frac = forecast_adj / (RA * sigma**2)\n", " alloc_pct = (alloc_frac * 100).clip(0, 100)\n", "\n", " # — behavioural boosts for having seen the robo —\n", " alloc_pct += np.where(has_robo, delta_robo,\n", " np.where(after_robo, delta_post, 0))\n", "\n", " # — blind robo allocation override & noise for everyone else —\n", " allocation = np.where(\n", " has_robo & mask_alloc_treat & follow_robo,\n", " alloc_pct, # blindly follow robo suggestion\n", " alloc_pct + np.random.normal(0, 5, n_participants) # add noise\n", " )\n", " allocation = allocation.clip(0, 100).round(2)\n", "\n", " # — record in your DataFrame —\n", " data[f'chosen_path_round_{round_num}'] = chosen\n", " data[f'best_forecast_round_{round_num}'] = best_forecast.round(6)\n", " data[f'forecast_round_{round_num}'] = forecast_adj.round(2)\n", " data[f'allocation_round_{round_num}'] = allocation.round(0)\n", " data[f'optimal_allocation_round_{round_num}'] = optimal_allocation.round(6)\n", "\n", "\n", "# Finally, have some participants who always answer the same thing across rounds to finish faster\n", " # 1) Decide how many “constant” respondents to inject\n", "num_const = max(1, int(0.01 * len(data))) # at least one\n", "\n", "# 2) Pick them at random\n", "const_idxs = np.random.choice(data.index, size=num_const, replace=False)\n", "\n", "# 3) List of your forecast/allocation columns\n", "forecast_cols = [f'forecast_round_{r}' for r in range(1, 31)]\n", "allocation_cols = [f'allocation_round_{r}' for r in range(1, 31)]\n", "\n", "# 4) Overwrite each selected participant’s answers with their round‑1 value\n", "for idx in const_idxs:\n", " const_fore = data.at[idx, forecast_cols[0]]\n", " const_alloc = data.at[idx, allocation_cols[0]]\n", " data.loc[idx, forecast_cols] = const_fore\n", " data.loc[idx, allocation_cols] = const_alloc\n", " data = data.copy()\n", "\n", "# Export to CSV\n", "data.to_csv('simulated_experiment_data.csv', index=False)\n", "paths.to_csv('return_paths.csv', index=False)\n", "print(\"Simulated data exported as 'simulated_experiment_data.csv' and return paths as 'return_paths.csv'\")\n" ] }, { "cell_type": "markdown", "id": "158264ae", "metadata": {}, "source": [] }, { "cell_type": "code", "execution_count": 4, "id": "827bbd52", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Index(['gender', 'age', 'education', 'occupation', 'income', 'stock_exp',\n", " 'lottery_allocation', 'RA_parameter', 'robo_condition',\n", " 'chosen_path_round_1',\n", " ...\n", " 'forecast_round_29', 'allocation_round_29',\n", " 'optimal_allocation_round_29', 'chosen_path_round_30',\n", " 'best_forecast_round_30', 'forecast_round_30', 'allocation_round_30',\n", " 'optimal_allocation_round_30', 'sum_paths', 'n_unique_paths'],\n", " dtype='object', length=161)\n" ] } ], "source": [ "print(data.columns)" ] }, { "cell_type": "code", "execution_count": 5, "id": "7215c137", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "fig, ax = plt.subplots()\n", "ax.boxplot(data['RA_parameter'])\n", "ax.set_ylabel('Risk Aversion Parameter')\n", "ax.set_title('Boxplot of RA_parameter Across Participants')\n", "plt.show()\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "611e7282", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots()\n", "ax.boxplot(data['lottery_allocation'])\n", "ax.set_ylabel('Lottery Allocation')\n", "ax.set_title('Boxplot of Lottery Allocation Across Participants')\n", "plt.show()\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "c6ffcbc9", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# First, aggregate all optimal allocations by path\n", "opt_per_path = {pid: [] for pid in path_ids}\n", "for r in range(1, n_rounds + 1):\n", " cp = data[f'chosen_path_round_{r}']\n", " oa = data[f'optimal_allocation_round_{r}']\n", " for pid in path_ids:\n", " opt_per_path[pid].extend(oa[cp == pid].tolist())\n", "\n", "box_data = [opt_per_path[pid] for pid in path_ids]\n", "best_vals = paths.set_index('path_id').loc[path_ids, 'best_forecast'].values\n", "\n", "# Plot\n", "fig, ax1 = plt.subplots()\n", "ax2 = ax1.twinx()\n", "\n", "# boxplot of optimal allocations\n", "ax1.boxplot(box_data, positions=path_ids)\n", "ax1.set_xlabel('Price Path ID')\n", "ax1.set_ylabel('Optimal Allocation (%)')\n", "\n", "# line of best forecasts\n", "ax2.plot(path_ids, best_vals, marker='o', linestyle='-')\n", "ax2.set_ylabel('Best Forecast')\n", "\n", "ax1.set_title('Optimal Allocation by Price Path\\nwith Best Forecast (Dual Axis)')\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 3, "id": "1189ed11-2363-4dbe-a645-c6969edfc106", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "# 1) Define the rounds\n", "rounds = list(range(1, 31))\n", "\n", "# 2) Forecast‐error boxplot by round\n", "# (absolute error: |forecast – best_forecast|)\n", "error_data = [\n", " (data[f'forecast_round_{r}'] - data[f'best_forecast_round_{r}']).abs()\n", " for r in rounds\n", "]\n", "\n", "fig, ax = plt.subplots()\n", "ax.boxplot(error_data, positions=rounds)\n", "ax.set_xlabel('Round')\n", "ax.set_ylabel('Absolute Forecast Error')\n", "ax.set_title('Forecast Error by Round\\n(Robo Rounds should show lower errors)')\n", "plt.show()\n", "\n", "\n", "# 3) Allocation boxplot by round\n", "alloc_data = [\n", " data[f'allocation_round_{r}']\n", " for r in rounds\n", "]\n", "\n", "fig, ax = plt.subplots()\n", "ax.boxplot(alloc_data, positions=rounds)\n", "ax.set_xlabel('Round')\n", "ax.set_ylabel('Allocation to Risky Asset (%)')\n", "ax.set_title('Allocation by Round\\n(Expect higher allocations in Robo Rounds)')\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 2, "id": "8ecbd26b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " count mean std min 25% \\\n", "optimal_allocation_round_1 49.0 48.442925 43.560912 0.0 0.428467 \n", "optimal_allocation_round_2 49.0 35.820821 40.756077 0.0 0.000000 \n", "optimal_allocation_round_3 49.0 44.480153 44.221892 0.0 0.044085 \n", "optimal_allocation_round_4 49.0 42.450197 45.132430 0.0 0.000000 \n", "optimal_allocation_round_5 49.0 53.138401 44.929508 0.0 0.503434 \n", "optimal_allocation_round_6 49.0 46.576364 45.736406 0.0 0.000000 \n", "optimal_allocation_round_7 49.0 54.672126 43.774520 0.0 1.651830 \n", "optimal_allocation_round_8 49.0 56.884619 43.468578 0.0 3.806636 \n", "optimal_allocation_round_9 49.0 46.546812 44.780443 0.0 0.000000 \n", "optimal_allocation_round_10 49.0 53.349824 43.758564 0.0 1.440192 \n", "optimal_allocation_round_11 49.0 43.310778 45.428391 0.0 0.000000 \n", "optimal_allocation_round_12 49.0 50.286441 45.690981 0.0 0.000000 \n", "optimal_allocation_round_13 49.0 41.378026 44.220961 0.0 0.000000 \n", "optimal_allocation_round_14 49.0 39.035542 42.081847 0.0 0.000000 \n", "optimal_allocation_round_15 49.0 60.298605 42.560047 0.0 22.281133 \n", "optimal_allocation_round_16 49.0 50.406186 43.030212 0.0 0.000000 \n", "optimal_allocation_round_17 49.0 47.837701 45.180455 0.0 0.000000 \n", "optimal_allocation_round_18 49.0 48.689614 42.716700 0.0 1.523170 \n", "optimal_allocation_round_19 49.0 51.108503 44.038346 0.0 1.387779 \n", "optimal_allocation_round_20 49.0 57.929594 42.761505 0.0 5.055326 \n", "optimal_allocation_round_21 49.0 41.178554 44.552853 0.0 0.000000 \n", "optimal_allocation_round_22 49.0 40.831392 41.901267 0.0 0.000000 \n", "optimal_allocation_round_23 49.0 52.709834 46.675577 0.0 0.000000 \n", "optimal_allocation_round_24 49.0 52.952565 41.832800 0.0 5.055326 \n", "optimal_allocation_round_25 49.0 52.440206 41.395359 0.0 10.312888 \n", "optimal_allocation_round_26 49.0 52.880914 45.543964 0.0 2.934620 \n", "optimal_allocation_round_27 49.0 53.679233 44.369611 0.0 0.428467 \n", "optimal_allocation_round_28 49.0 49.076378 43.911061 0.0 0.000000 \n", "optimal_allocation_round_29 49.0 52.206032 46.732463 0.0 0.000000 \n", "optimal_allocation_round_30 49.0 44.983671 43.964136 0.0 0.000000 \n", "\n", " 50% 75% max \n", "optimal_allocation_round_1 36.988373 100.000000 100.0 \n", "optimal_allocation_round_2 15.996833 65.794285 100.0 \n", "optimal_allocation_round_3 36.885310 100.000000 100.0 \n", "optimal_allocation_round_4 13.937797 100.000000 100.0 \n", "optimal_allocation_round_5 53.963037 100.000000 100.0 \n", "optimal_allocation_round_6 30.437866 100.000000 100.0 \n", "optimal_allocation_round_7 57.416834 100.000000 100.0 \n", "optimal_allocation_round_8 66.702268 100.000000 100.0 \n", "optimal_allocation_round_9 41.835352 100.000000 100.0 \n", "optimal_allocation_round_10 57.821282 100.000000 100.0 \n", "optimal_allocation_round_11 19.217824 100.000000 100.0 \n", "optimal_allocation_round_12 43.480125 100.000000 100.0 \n", "optimal_allocation_round_13 18.802536 100.000000 100.0 \n", "optimal_allocation_round_14 30.229923 92.103679 100.0 \n", "optimal_allocation_round_15 89.086002 100.000000 100.0 \n", "optimal_allocation_round_16 46.139393 100.000000 100.0 \n", "optimal_allocation_round_17 37.316100 100.000000 100.0 \n", "optimal_allocation_round_18 44.777176 100.000000 100.0 \n", "optimal_allocation_round_19 46.420908 100.000000 100.0 \n", "optimal_allocation_round_20 61.551648 100.000000 100.0 \n", "optimal_allocation_round_21 15.847965 100.000000 100.0 \n", "optimal_allocation_round_22 27.883906 100.000000 100.0 \n", "optimal_allocation_round_23 48.879174 100.000000 100.0 \n", "optimal_allocation_round_24 49.579839 100.000000 100.0 \n", "optimal_allocation_round_25 45.731678 100.000000 100.0 \n", "optimal_allocation_round_26 54.671130 100.000000 100.0 \n", "optimal_allocation_round_27 56.204280 100.000000 100.0 \n", "optimal_allocation_round_28 50.982278 100.000000 100.0 \n", "optimal_allocation_round_29 62.449639 100.000000 100.0 \n", "optimal_allocation_round_30 30.564042 100.000000 100.0 \n" ] } ], "source": [ "# 1) Filter control group\n", "control = data[data['robo_condition'] == 1]\n", "\n", "# 2) Columns for optimal allocation by round\n", "cols = [f'optimal_allocation_round_{r}' for r in range(1, 31)]\n", "\n", "# 3) Compute and transpose summary stats\n", "sumstats = control[cols].describe().T\n", "\n", "# 4) Display\n", "print(sumstats)" ] }, { "cell_type": "code", "execution_count": 4, "id": "094b68c9-b9ba-4394-81ac-9ae2ec29fdd3", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Forecast error lower in robo rounds? t=8.030, p=0.000\n", "Allocation higher in robo rounds? t=-5.887, p=0.000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_50937/987590985.py:27: RuntimeWarning: invalid value encountered in divide\n", " err_robo = (err * mask_robo).sum(axis=1) / mask_robo.sum(axis=1)\n", "/var/folders/sq/fgb7rfns7vx8nr060cbf_g2r0000gp/T/ipykernel_50937/987590985.py:31: RuntimeWarning: invalid value encountered in divide\n", " alloc_robo = (alloc * mask_robo).sum(axis=1) / mask_robo.sum(axis=1)\n" ] } ], "source": [ "from scipy.stats import ttest_rel\n", "\n", "rounds = np.arange(1, 31)\n", "n = len(data)\n", "\n", "# Build forecast-error and allocation matrices (n × 30)\n", "fc = data[[f'forecast_round_{r}' for r in rounds]].values\n", "bf = data[[f'best_forecast_round_{r}' for r in rounds]].values\n", "err = np.abs(fc - bf)\n", "\n", "alloc = data[[f'allocation_round_{r}' for r in rounds]].values\n", "\n", "# Participant‐level robo_condition array\n", "robo_cond = data['robo_condition'].values # length n\n", "\n", "# Boolean mask of robo‐rounds per participant\n", "mask_robo = np.array([\n", " [(6 <= r <= 25) and (rc != 1) for r in rounds]\n", " for rc in robo_cond\n", "])\n", "mask_non = ~mask_robo\n", "\n", "# Compute means, but only for participants with at least one robo round\n", "valid = mask_robo.sum(axis=1) > 0\n", "\n", "# Per‐participant mean absolute error\n", "err_robo = (err * mask_robo).sum(axis=1) / mask_robo.sum(axis=1)\n", "err_non = (err * mask_non).sum(axis=1) / mask_non.sum(axis=1)\n", "\n", "# Per‐participant mean allocation\n", "alloc_robo = (alloc * mask_robo).sum(axis=1) / mask_robo.sum(axis=1)\n", "alloc_non = (alloc * mask_non).sum(axis=1) / mask_non.sum(axis=1)\n", "\n", "# Filter out the never‐robo folks\n", "err_robo = err_robo[valid]\n", "err_non = err_non[valid]\n", "alloc_robo = alloc_robo[valid]\n", "alloc_non = alloc_non[valid]\n", "\n", "# Paired t‐tests\n", "t_err, p_err = ttest_rel(err_non, err_robo)\n", "t_alloc, p_alloc = ttest_rel(alloc_non, alloc_robo)\n", "\n", "print(f'Forecast error lower in robo rounds? t={t_err:.3f}, p={p_err:.3f}')\n", "print(f'Allocation higher in robo rounds? t={t_alloc:.3f}, p={p_alloc:.3f}')\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "ba7211d8", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " count mean std min 25% \\\n", "optimal_allocation_round_1 49.0 0.704633 0.804097 0.0 0.004285 \n", "optimal_allocation_round_2 49.0 0.983711 2.101269 0.0 0.000000 \n", "optimal_allocation_round_3 49.0 0.826851 1.096910 0.0 0.000441 \n", "optimal_allocation_round_4 49.0 0.792834 1.108951 0.0 0.000000 \n", "optimal_allocation_round_5 49.0 1.037846 1.210902 0.0 0.005034 \n", "optimal_allocation_round_6 49.0 1.099726 1.673870 0.0 0.000000 \n", "optimal_allocation_round_7 49.0 1.321022 2.005389 0.0 0.016518 \n", "optimal_allocation_round_8 49.0 0.958938 1.012897 0.0 0.038066 \n", "optimal_allocation_round_9 49.0 1.486335 2.388544 0.0 0.000000 \n", "optimal_allocation_round_10 49.0 1.415328 2.051630 0.0 0.014402 \n", "optimal_allocation_round_11 49.0 0.866922 1.201417 0.0 0.000000 \n", "optimal_allocation_round_12 49.0 1.031025 1.413132 0.0 0.000000 \n", "optimal_allocation_round_13 49.0 0.908315 1.682278 0.0 0.000000 \n", "optimal_allocation_round_14 49.0 0.642499 1.023117 0.0 0.000000 \n", "optimal_allocation_round_15 49.0 1.842914 2.637762 0.0 0.222811 \n", "optimal_allocation_round_16 49.0 0.924289 1.448183 0.0 0.000000 \n", "optimal_allocation_round_17 49.0 1.027078 1.414992 0.0 0.000000 \n", "optimal_allocation_round_18 49.0 1.066674 1.628260 0.0 0.015232 \n", "optimal_allocation_round_19 49.0 1.274369 1.774240 0.0 0.013878 \n", "optimal_allocation_round_20 49.0 1.115502 1.205143 0.0 0.050553 \n", "optimal_allocation_round_21 49.0 0.747832 1.168109 0.0 0.000000 \n", "optimal_allocation_round_22 49.0 0.677417 0.982805 0.0 0.000000 \n", "optimal_allocation_round_23 49.0 1.432432 1.881143 0.0 0.000000 \n", "optimal_allocation_round_24 49.0 0.990965 1.553084 0.0 0.050553 \n", "optimal_allocation_round_25 49.0 1.376868 2.040757 0.0 0.103129 \n", "optimal_allocation_round_26 49.0 1.121342 1.257581 0.0 0.029346 \n", "optimal_allocation_round_27 49.0 1.013191 1.237827 0.0 0.004285 \n", "optimal_allocation_round_28 49.0 0.988960 1.554195 0.0 0.000000 \n", "optimal_allocation_round_29 49.0 1.411898 2.041377 0.0 0.000000 \n", "optimal_allocation_round_30 49.0 1.477408 2.405352 0.0 0.000000 \n", "\n", " 50% 75% max \n", "optimal_allocation_round_1 0.369884 1.216440 3.409522 \n", "optimal_allocation_round_2 0.159968 0.657943 9.321665 \n", "optimal_allocation_round_3 0.368853 1.257574 4.370413 \n", "optimal_allocation_round_4 0.139378 1.368869 4.200674 \n", "optimal_allocation_round_5 0.539630 1.706438 4.318474 \n", "optimal_allocation_round_6 0.304379 1.268759 7.185514 \n", "optimal_allocation_round_7 0.574168 1.651830 9.180285 \n", "optimal_allocation_round_8 0.667023 1.378529 3.806636 \n", "optimal_allocation_round_9 0.418354 2.306929 9.321665 \n", "optimal_allocation_round_10 0.578213 2.122477 9.321665 \n", "optimal_allocation_round_11 0.192178 1.456803 5.055326 \n", "optimal_allocation_round_12 0.434801 1.658999 7.614251 \n", "optimal_allocation_round_13 0.188025 1.181734 8.742765 \n", "optimal_allocation_round_14 0.302299 0.921037 4.803328 \n", "optimal_allocation_round_15 0.890860 2.226807 9.321665 \n", "optimal_allocation_round_16 0.461394 1.343297 8.742765 \n", "optimal_allocation_round_17 0.373161 1.273297 4.318474 \n", "optimal_allocation_round_18 0.447772 1.230904 7.359640 \n", "optimal_allocation_round_19 0.464209 1.902974 8.043732 \n", "optimal_allocation_round_20 0.615516 1.645354 4.200674 \n", "optimal_allocation_round_21 0.158480 1.213200 6.070722 \n", "optimal_allocation_round_22 0.278839 1.051491 4.252977 \n", "optimal_allocation_round_23 0.488792 2.265495 8.595372 \n", "optimal_allocation_round_24 0.495798 1.180121 9.321665 \n", "optimal_allocation_round_25 0.457317 1.522367 8.610165 \n", "optimal_allocation_round_26 0.546711 2.125779 3.806636 \n", "optimal_allocation_round_27 0.562043 1.456803 5.055326 \n", "optimal_allocation_round_28 0.509823 1.456803 8.742765 \n", "optimal_allocation_round_29 0.624496 1.761609 8.576345 \n", "optimal_allocation_round_30 0.305640 1.838191 9.321665 \n" ] } ], "source": [ "\n", "# 1) Filter control group\n", "control = data[data['robo_condition'] == 1]\n", "#control=data\n", "# 2) Columns for optimal allocation by round\n", "cols = [f'optimal_allocation_round_{r}' for r in range(1, 31)]\n", "\n", "# 3) Compute and transpose summary stats\n", "sumstats = control[cols].describe().T\n", "\n", "# 4) Display\n", "print(sumstats)" ] }, { "cell_type": "code", "execution_count": 5, "id": "3c9fcc8c", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "# 1) Compute each participant’s average allocation across all 30 rounds\n", "alloc_cols = [f'allocation_round_{r}' for r in range(1, 31)]\n", "data['mean_alloc'] = data[alloc_cols].mean(axis=1)\n", "\n", "# 2) Plot mean allocation by Gender\n", "means_gender = data.groupby('gender')['mean_alloc'].mean()\n", "fig, ax = plt.subplots()\n", "ax.bar(means_gender.index, means_gender.values)\n", "ax.set_xlabel('Gender')\n", "ax.set_ylabel('Mean Allocation (%)')\n", "ax.set_title('Mean Allocation by Gender')\n", "plt.show()\n", "\n", "# 3) Plot mean allocation by Income\n", "means_income = data.groupby('income')['mean_alloc'].mean()\n", "fig, ax = plt.subplots()\n", "ax.bar(means_income.index, means_income.values)\n", "ax.set_xlabel('Income')\n", "ax.set_ylabel('Mean Allocation (%)')\n", "ax.set_title('Mean Allocation by Income')\n", "plt.show()\n", "\n", "# 4) Plot mean allocation by Stock Market Experience\n", "means_stock = data.groupby('stock_exp')['mean_alloc'].mean()\n", "fig, ax = plt.subplots()\n", "ax.bar(means_stock.index, means_stock.values)\n", "ax.set_xlabel('Stock Market Experience')\n", "ax.set_ylabel('Mean Allocation (%)')\n", "ax.set_title('Mean Allocation by Stock Market Experience')\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 3, "id": "bb99151b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Unique sums of path‐IDs: [465]\n", "Unique counts of seen paths: [30]\n" ] } ], "source": [ "\n", "# 1) List of your chosen_path columns\n", "path_cols = [f'chosen_path_round_{r}' for r in range(1, 31)]\n", "\n", "# 2) Sum of path IDs seen by each participant\n", "data['sum_paths'] = data[path_cols].sum(axis=1)\n", "\n", "# 3) Count of unique paths seen per participant\n", "data['n_unique_paths'] = data[path_cols].nunique(axis=1)\n", "\n", "# 4) Inspect results\n", "print(\"Unique sums of path‐IDs:\", data['sum_paths'].unique())\n", "print(\"Unique counts of seen paths:\", data['n_unique_paths'].unique())\n", "\n", "# 5) Optional assertions\n", "assert (data['sum_paths'] == 465).all(), \"⚠️ Some participants' path‐ID sums differ from 465\"\n", "assert (data['n_unique_paths'] == 30).all(), \"⚠️ Some participants didn't see 30 unique paths\"" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.6" } }, "nbformat": 4, "nbformat_minor": 5 }